#ifndef _HTTPDATA_H
#define _HTTPDATA_H

#include "Channel.h"
#include "DDAP.pb.h"
#include "ECCOper.h"
#include "EventLoop.h"
#include "MessageDispatcher.h"
#include "SymmetricEncryption.h"
#include "blockchainoperator.h"
#include "utils.h"

#include <cstddef>
#include <functional>
#include <map>
#include <memory>
#include <openssl/types.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <sys/epoll.h>
#include <unistd.h>
#include <unordered_map>
#include <vector>
/*
DdapData 类封装了处理 HTTP 请求的各个阶段的方法和状态。它通过不同的枚举类型来定义处理阶段、解析状态、连接状态、HTTP
方法和版本等。该类主要负责解析 HTTP 请求，管理连接状态，处理读写事件，并通过关联计时器来管理超时。通过这些封装，HttpData
类提供了一个结构化的框架来处理 HTTP 请求和响应
*/
namespace droneswarm
{

    class TimerNode;
    enum ProcessState  //处理阶段的枚举
    {
        // STATE_PARSE_URI = 1,          //解析URI阶段
        // STATE_PARSE_HEADERS,          //解析HTTP头部阶段
        // STATE_RECV_BODY,              //接收请求体阶段
        // STATE_ANALYSIS,               //分析请求阶段
        // STATE_FINSH,                  //完成处理阶段
        STATE_PARSE_NEEDHMACMESSAGE = 1,  //解析NEEDHMACMESSAGE消息
        STATE_PARSE_ENCRYPTMESSAGE,       //解析ENCRYPTMESSAGE消息
        STATE_PARSE_FULLMESSAGE,          //解析FULLMESSAGE消息
        STATE_MESSAGEINFO_ANALYSIS,       //分析MESSAGEINFO结构体阶段
        STATE_MESSAGE_FINSH               //完成处理阶段
    };

    //定义解析URI的不同阶段的枚举
    enum NEEDHMACMESSAGEState
    {
        PARSE_NEEDHMACMESSAGE_AGAIN = 1,  //再次解析NEEDHMACMESSAGE
        PARSE_NEEDHMACMESSAGE_ERROR,      //解析NEEDHMACMESSAGE出错
        PARSE_NEEDHMACMESSAGE_SUCESS      //解析NEEDHMACMESSAGE成功
    };

    enum ENCRYPTMESSAGEState
    {
        PARSE_ENCRYPTMESSAGE_ERROR = 1,  //解析ENCRYPTMESSAGE出错
        PARSE_ENCRYPTMESSAGE_SUCESS      //解析ENCRYPTMESSAGE成功
    };

    enum FULLMESSAGEState
    {
        PARSE_FULLMESSAGE_ERROR = 1,  //解析FULLMESSAGE出错
        PARSE_FULLMESSAGE_SUCESS      //解析FULLMESSAGE成功
    };

    enum MESSAGEINFOState
    {
        PARSE_MESSAGEINFO_ERROR = 1,
        PARSE_MESSAGEINFO_SUCESS
    };

    //定义解析URI的不同阶段的枚举
    enum URIState
    {
        PARSE_URI_AGAIN = 1,  //再次解析URI
        PARSE_URI_ERROR,      //解析URI出错
        PARSE_URI_SUCESS      //解析URI成功
    };

    //定义解析HTTP头部的不同状态
    enum HeaderState
    {
        PARSE_HEADER_SUCESS = 1,  //解析成功
        PARSE_HEADER_AGAIN,       //再一次解析
        PARSE_HEADER_ERROR        //解析出错
    };

    //定义HTTP解析状态的枚举
    enum AnalysisState
    {
        ANALYSIS_SUCCESS = 1,
        ANALYSIS_ERROR
    };

    //定义HTTP请求头部解析过程中的不同阶段。
    // HTTP请求头部由键值对组成，key和value用:分隔。
    enum ParseState
    {
        H_START = 0,  //起始状态，表示开始解析一个新的头部字段
        H_KEY,
        H_COLON,              //解析头部字段名后的冒号的状态，通常头部冒号后面会跟一个空格
        H_SPACES_AFER_COLON,  //解析冒号后面的空格状态
        H_VALUE,              //解析value的状态
        H_CR,                 //解析回车符的状态
        H_LF,                 //解析换行符的状态
        H_END_CR,             //解析消息头部结束的回车符的状态
        H_END_LF              //解析消息头部结束的换行符的状态
    };

    enum ConnectionState
    {
        H_CONNECTED = 0,  //表示连接已经建立
        H_DISCONNECTING,  //表示正在断开连接
        H_DISCONNECTED    //表示连接已经断开
    };

    enum HttpMethod
    {
        METHOD_POST = 1,  //表示HTTP的POST请求，通常用于提交数据到服务器。
        METHOD_GET,       //表示HTTP的GET请求，通常用于从服务器获取数据。
        METHOD_HEAD  //表示HTTP的HEAD请求，通常用于获取资源的元信息，如头信息，但不返回实体主体。
    };

    enum HttpVersion
    {
        HTTP_10 = 1,
        HTTP_11
    };

    // class MimeType
    // {
    // private:
    //     static void init();
    //     static std::unordered_map< std::string, std::string > mime;
    //     MimeType();
    //     MimeType( const MimeType &m );

    // public:
    //     static std::string getMime( const std::string &suffix );

    // private:
    //     static pthread_once_t once_control;
    // };

    // std::enable_shared_from_this<DdapData>模板类，继承这个模板类的类，可以使用
    // shared_from_this()方法获取一个指向自身的std::shared_ptr 对象。
    //继承 std::enable_shared_from_this 通常用于在类内部需要将自身作为 std::shared_ptr
    //参数传递给其他函数或者对象的情况下，以确保对象的生命周期管理正确。
    class DdapData : public std::enable_shared_from_this< DdapData >
    {
    public:
        DdapData( EventLoop *loop, int fd, unsigned char symmetricKey[ 32 ] );
        ~DdapData();
        void reset();                                                               // 重置 DdapData 对象
        void seperateTimer();                                                       // 分离计时器
        void linkTimer( std::shared_ptr< TimerNode > mtimer ) { timer_ = mtimer; }  // 关联计时器
        std::shared_ptr< Channel > getChannel() { return channel_; }
        void bindDispatcher( MessageDispatcher *dp ) { msgDp_ = dp; }
        EventLoop *getLoop() { return loop_; }
        void handleClose();
        void newEvent();

    private:
        EventLoop *loop_;
        std::shared_ptr< Channel > channel_;
        int fd_;
        MessageDispatcher *msgDp_;
        std::string inBuffer_;
        std::string outBuffer_;
        bool error_;
        //加密操作对象
        ECCOperator eccOp_;  //对称密钥
        unsigned char symmetricKey_[ 32 ];
        //std::string realData;
        ConnectionState connectionState_;  // 连接状态
        needHMACMessage needHmacMsg_;
        EncrptyMessage encryptMsg_;
        SigningMessage signingMsg_;
        FullMessage fullMsg_;
        unsigned char plainText_[ 4096 ];
        unsigned char cipherText_[ 4096 ];
        size_t cipherTextLen_;
        int plainTextLen_;
        SymmetricEncryption symm_;
        messageInfo msgInfo_;
        int nowReadPos_;                    // 当前读取位置
        ProcessState state_;                // 处理阶段状态
        bool keepAlive_;                    // 保持连接标志
        std::weak_ptr< TimerNode > timer_;  // 计时器，用于管理超时
        bool isExistHeader;
        // std::shared_ptr< SSLLayer > SSLLayer_;

    private:
        void handleRead();
        void handleWrite();
        void handleConn();  //这个具体的函数绑定到了channel类的handleConn函数中，每次在处理完
        void handleError( int fd, int err_num, std::string short_msg );
        NEEDHMACMESSAGEState parseNeedHmacMessage();
        ENCRYPTMESSAGEState parseEncryptMessage();
        FULLMESSAGEState parseFullMessage();
        AnalysisState analysisMessage();
        std::vector< DroneData > parseDroneData( std::string data );
        bool constructProtobufMessage( MessageType mt, std::string &sendData, DataType dt = NOTBOTH );
        bool getBlockIllegalData( std::string &data );
        bool getBlockLegitimateData( std::string &data );
        bool publishDroneInfoToBlock( std::string data );
        std::string getDataFromDispatch( std::string &string );
    };
}  // namespace droneswarm
#endif